function exampleFunction() {
  return {
    name: '小美',
    age: 30
  };
}

// 使用ReturnType获取exampleFunction的返回类型
type FunctionReturnType = ReturnType<typeof exampleFunction>;

// FunctionReturnType的类型是 { name: string; age: number; }






type MyRecord<K extends keyof any, T> = {
  [P in K]: T;
};

// 使用示例
type Person = MyRecord<'name' | 'age', string>;

const person: Person = {
  name: 'Alice',
  age: '25'
};





// TypeScript 提供了许多内置的工具类型（Utility Types）来帮助开发者处理类型转换和组合。以下是一些常用内置工具类型的简单实现，以及它们的用法：

// Partial<T> - 将类型 T 的所有属性设置为可选的。
// typescript
type MyPartial<T> = {
  [P in keyof T]?: T[P];
};

// 使用示例
interface Person {
  name: string;
  age: number;
}

type SomePerson = MyPartial<Person>;
// Required<T> - 将类型 T 的所有属性设置为必需的。
// typescript
type MyRequired<T> = {
  [P in keyof T]-?: T[P];
};

// 使用示例
type FullPerson = MyRequired<SomePerson>;
// Readonly<T> - 将类型 T 的所有属性设置为只读的。
// typescript
type MyReadonly<T> = {
  readonly [P in keyof T]: T[P];
};

// 使用示例
type ReadonlyPerson = MyReadonly<Person>;
// Record<K, T> - 创建一个对象类型，其属性键为 K 类型，属性值为 T 类型。
// typescript
type MyRecord<K extends keyof any, T> = {
  [P in K]: T;
};

// 使用示例
type PersonRecord = MyRecord<'name' | 'age', string>;
// Pick<T, K> - 从类型 T 中选取一组属性 K。
// typescript
type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

// 使用示例
type PersonName = MyPick<Person, 'name'>;
// Omit<T, K> - 从类型 T 中排除一组属性 K。
// typescript
type MyOmit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

// 使用示例
type PersonAge = MyOmit<Person, 'name'>;
// Exclude<T, U> - 从类型 T 中排除可以赋值给 U 的类型。
// typescript
type MyExclude<T, U> = T extends U ? never : T;

// 使用示例
type T1 = MyExclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'
// NonNullable<T> - 从类型 T 中排除 null 和 undefined。
// typescript
type MyNonNullable<T> = T extends null | undefined ? never : T;

// 使用示例
type T2 = MyNonNullable<string | number | undefined>; // string | number
// 以上是一些 TypeScript 内置工具类型的简单实现。在实际开发中，直接使用 TypeScript 提供的内置工具类型通常更方便、更安全，因为它们经过了严格的测试和优化。